home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 09 - 1993 / 09.12 Dec 93 / Apple π / CAppPiApp.cp < prev    next >
Encoding:
Text File  |  1993-10-01  |  7.8 KB  |  310 lines  |  [TEXT/KAHL]

  1. /*****
  2.  * CAppPiApp.c
  3.  *
  4.  *    Application methods for a typical application.
  5.  *
  6.  *  Copyright © 1990 Symantec Corporation.  All rights reserved.
  7.  *
  8.  *****/
  9.  
  10. #include "CAppPiApp.h"
  11. #include "CAppPiDoc.h"
  12. #include "CAboutBoxDirector.h"
  13. #include <Commands.h>
  14.  
  15. extern    OSType    gSignature;
  16.  
  17. #define        kExtraMasters        4
  18. #define        kRainyDayFund        20480
  19. #define        kCriticalBalance    20480
  20. #define        kToolboxBalance        20480
  21.  
  22.  
  23. /***
  24.  * IAppPiApp
  25.  *
  26.  *    Initialize the application. Your initialization method should
  27.  *    at least call the inherited method. If your application class
  28.  *    defines its own instance variables or global variables, this
  29.  *    is a good place to initialize them.
  30.  *
  31.  ***/
  32.  
  33. void CAppPiApp::IAppPiApp(void)
  34.  
  35. {
  36.     CApplication::IApplication( kExtraMasters, kRainyDayFund, 
  37.                         kCriticalBalance, kToolboxBalance);
  38.     
  39.  
  40. /*  The parameters to IApplication are the number of times to call  
  41.     MoreMasters, the total number of bytes of heap space to reserve for                       
  42.     monitoring low memory situations, and the portion of the memory
  43.     reserve to set aside for critical operations and toolbox calls.
  44.     
  45.     Four (4) is a reasonable number of MoreMasters calls,                           
  46.     but you should determine a good number for your application                     
  47.     by observing the heap using Lightsbug,                                              
  48.     TMON, or Macsbug. Set this parameter to zero, give your                         
  49.     program a rigorous work-out, then look at the heap and count                        
  50.     how many master pointer blocks have been allocated. Master                      
  51.     pointer blocks are nonrelocatable and have a size of $100                           
  52.     (hex). You should call MoreMasters at least this many                               
  53.     times -- add a few extra just to be safe. The purpose of all                        
  54.     this preflighting is to prevent heap fragmentation. You                             
  55.     don't want the Memory Manager to call MoreMasters and                           
  56.     create a nonrelocatable block in the middle of your heap. By                        
  57.     calling MoreMasters at the very beginning of the program,                           
  58.     you ensure that these blocks are allocated in a group at the                        
  59.     bottom of the heap. 
  60.                                                                         
  61.     The memory reserve is a safeguard for handling low memory                   
  62.     conditions and is used by the GrowMemory method in                              
  63.     CApplication (check there for more comments). In general,                           
  64.     your program should never request a memory block greater                        
  65.     than this reserve size without explicitly checking in                               
  66.     advance whether there is enough free memory to satisfy the                      
  67.     the request.
  68.                                                                                     
  69.  */
  70.  
  71. }
  72.  
  73.  
  74.  
  75. /***
  76.  * SetUpFileParameters
  77.  *
  78.  *    In this routine, you specify the kinds of files your
  79.  *    application opens.
  80.  *
  81.  *
  82.  ***/
  83.  
  84. void CAppPiApp::SetUpFileParameters(void)
  85.  
  86. {
  87.     inherited::SetUpFileParameters();    /* Be sure to call the default method */
  88.  
  89.         /**
  90.          **    sfNumTypes is the number of file types
  91.          **    your application knows about.
  92.          **    sfFileTypes[] is an array of file types.
  93.          **    You can define up to 4 file types in
  94.          **    sfFileTypes[].
  95.          **
  96.          **/
  97.  
  98.     sfNumTypes = 1;
  99.     sfFileTypes[0] = 'TEXT';
  100.  
  101.         /**
  102.          **    Although it's not an instance variable,
  103.          **    this method is a good place to set the
  104.          **    gSignature global variable. Set this global
  105.          **    to your application's signature. You'll use it
  106.          **    to create a file (see CFile::CreateNew()).
  107.          **
  108.          **/
  109.  
  110.     gSignature = '?\??\?';
  111. }
  112.  
  113. /***
  114.  * SetUpMenus 
  115.  *
  116.  * Set up menus which must be created at run time, such as a
  117.  * Font menu. You can eliminate this method if your application
  118.  * does not have any such menus.
  119.  *
  120. ***/
  121.  
  122.  void CAppPiApp::SetUpMenus()
  123.  {
  124.  
  125.   inherited::SetUpMenus();  /*  Superclass takes care of adding     
  126.                                 menus specified in a MBAR id = 1    
  127.                                 resource    
  128.                             */                          
  129.  
  130.         /* Add your code for creating run-time menus here */    
  131.  }
  132.  
  133.  
  134.  
  135. /***
  136.  * DoCommand
  137.  *
  138.  *    Your application will probably handle its own commands.
  139.  *    Remember, the command numbers from 1-1023 are reserved.
  140.  *  The file Commands.h contains all the predefined TCL
  141.  *  commands.
  142.  *
  143.  *    Be sure to call the default method, so you can get
  144.  *    the default behvior for standard commands.
  145.  *
  146.  ***/
  147. void CAppPiApp::DoCommand(long theCommand)
  148.  
  149. {
  150.     CAboutBoxDirector    *about;
  151.     
  152.     switch (theCommand) {
  153.     
  154.         case cmdAbout:
  155.             about = new CAboutBoxDirector;
  156.             about->IAboutBoxDirector (this, 1000);
  157.             about->About ();
  158.             break;
  159.     
  160.         default:    inherited::DoCommand(theCommand);
  161.                     break;
  162.     }
  163. }
  164.  
  165.  
  166. /***
  167.  *
  168.  * UpdateMenus 
  169.  *
  170.  *   Perform menu management tasks
  171.  *
  172. ***/
  173.  
  174.  void CAppPiApp::UpdateMenus()
  175.  {
  176.   inherited::UpdateMenus();     /* Enable standard commands */      
  177.  
  178.     /* Enable the commands handled by your Application class */ 
  179.  }
  180.  
  181.  
  182. /***
  183.  * Exit
  184.  *
  185.  *    Chances are you won't need this method.
  186.  *    This is the last chance your application gets to clean up
  187.  *  things like temporary files before terminating.
  188.  *
  189.  ***/
  190.  
  191. void CAppPiApp::Exit()
  192.  
  193. {
  194.     /* your exit handler here */
  195. }
  196.  
  197.  
  198. /***
  199.  * CreateDocument
  200.  *
  201.  *    The user chose New from the File menu.
  202.  *    In this method, you need to create a document and send it
  203.  *    a NewFile() message.
  204.  *
  205.  ***/
  206.  
  207. void CAppPiApp::CreateDocument()
  208.  
  209. {
  210.     CAppPiDoc    *theDocument = NULL;
  211.     
  212.     TRY
  213.     {
  214.         theDocument = new(CAppPiDoc);
  215.             
  216.             /**
  217.              **    Send your document an initialization
  218.              **    message. The first argument is the
  219.              **    supervisor (the application). The second
  220.              **    argument is TRUE if the document is printable.
  221.              **
  222.              **/
  223.         
  224.         theDocument->IAppPiDoc(this, TRUE);
  225.     
  226.             /**
  227.              **    Send the document a NewFile() message.
  228.              **    The document will open a window, and
  229.              **    set up the heart of the application.
  230.              **
  231.              **/
  232.         theDocument->NewFile();
  233.     }
  234.     
  235.     CATCH
  236.     {
  237.         /*
  238.          * This exception handler gets executed if a failure occurred 
  239.          * anywhere within the scope of the TRY block above. Since 
  240.          * this indicates that a new doc could not be created, we
  241.          * check if an object had been allocated and if it has, send 
  242.          * it a Dispose message. The exception will propagate up to
  243.          * CSwitchboard's exception handler, which handles displaying
  244.          * an error alert.
  245.          */
  246.          
  247.          if (theDocument) theDocument->Dispose();
  248.  
  249.     }
  250.     ENDTRY;
  251. }
  252.  
  253. /***
  254.  * OpenDocument
  255.  *
  256.  *    The user chose Open… from the File menu.
  257.  *    In this method you need to create a document
  258.  *    and send it an OpenFile() message.
  259.  *
  260.  *    The macSFReply is a good SFReply record that contains
  261.  *    the name and vRefNum of the file the user chose to
  262.  *    open.
  263.  *
  264.  ***/
  265.  
  266. void CAppPiApp::OpenDocument(SFReply *macSFReply)
  267.  
  268. {
  269.     CAppPiDoc    *theDocument = NULL;
  270.     
  271.     TRY
  272.     {
  273.     
  274.         theDocument = new(CAppPiDoc);
  275.             
  276.             /**
  277.              **    Send your document an initialization
  278.              **    message. The first argument is the
  279.              **    supervisor (the application). The second
  280.              **    argument is TRUE if the document is printable.
  281.              **
  282.              **/
  283.         
  284.         theDocument->IAppPiDoc(this, TRUE);
  285.     
  286.             /**
  287.              **    Send the document an OpenFile() message.
  288.              **    The document will open a window, open
  289.              **    the file specified in the macSFReply record,
  290.              **    and display it in its window.
  291.              **
  292.              **/
  293.         theDocument->OpenFile(macSFReply);
  294.     }
  295.     
  296.     CATCH
  297.     {
  298.         /*
  299.          * This exception handler gets executed if a failure occurred 
  300.          * anywhere within the scope of the TRY block above. Since 
  301.          * this indicates that the document could not be opened, we
  302.          * send it a Dispose message. The exception will propagate up to
  303.          * CSwitchboard's exception handler, which handles displaying
  304.          * an error alert.
  305.          */
  306.          
  307.          if (theDocument) theDocument->Dispose();
  308.     }
  309.     ENDTRY;
  310. }